Developer CD Series 1997 July: Mac OS SDK

home *** CD-ROM | disk | FTP | other *** search

/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / QuickDraw GX / Programming Stuff / Sample Code / Typography Samples / Style Layout ƒ / Style Layout.c < prev next >

Wrap

C/C++ Source or Header | 1996-06-18 | 13.9 KB | 446 lines | [TEXT/KAHL]

/**\ |**| ===================================================================== |**| |**| Style Layout.c |**| |**| This file contains the calls that this sample needs to make |**| the QuickDraw GX shell work correctly. |**| |**| QuickDraw GX Libraries Used: |**| "ColorLibrary.c", "FontLibrary.c", "GraphicsDebugLibrary.c", |**| "GraphicsLibrary.c", "LayoutLibrary.c", "ShapeLibrary.c", |**| TextLibrary.c and "TransformLibrary.c". |**| |**| 6/96 bob Updated #includes to support changed GX Library names. |**| Updated the copyright date. |**| |**| ©1990 - 1996 Apple Computer, Inc. |**| All rights reserved. |**| |**| ===================================================================== \**/ #include "QDGX shell.h" #include <GXLayout.h> #include "LayoutLibrary.h" /**\ |**| --------------------------------------------------------------------- |**| PROTOTYPES |**| --------------------------------------------------------------------- \**/ // funtions required by shell void DoSetup (void); void DoDraw (WindowPtr wind, Boolean updating); OSErr DoCreateNew (void); void DoDispose (WindowPtr wind); void DoIdle (WindowPtr wind); void DoTeardown (void); void DoClick (WindowPtr wind, Point p); // private functions OSErr DoWindowInit (WindowPtr wind); void CreateSampleImage (WindowPtr wind); /**\ |**| --------------------------------------------------------------------- |**| ENUMS |**| --------------------------------------------------------------------- \**/ enum { rWindResource = 128 }; /**\ |**| --------------------------------------------------------------------- |**| GLOBALS |**| --------------------------------------------------------------------- \**/ // If gDebugging = TRUE, graphics library errors and notices will be posted. This // functionality will only work with the "debugging" version of QuickDraw GX. // If the debugging version is not installed, nothing bad will happen, but these // functions will not work. Boolean gDebugging = true; // Set "gGiveMeValidation" to TRUE if you want receive run-time validation. Boolean gGiveMeValidation = true; // gGraphicsHeapSize sets the size of the graphics heap created by calling the // GXNewGraphicsClient routine in main () within QuickDraw GX shell.c. You can determine // the amount of graphics heap required by using GraphicsBug. I'm giving it 600K, // since we need abunch if we have several windows open. long gGraphicsHeapSize = 600; // gOurPrintingOverrideUPP is a universal proc pointer for our printing event // override. This is so that our override can be native PowerPC code if necessary. GXPrintingEventUPP gOurPrintingOverrideUPP; /**\ |**| --------------------------------------------------------------------- |**| DoSetup() |**| Here's where we initialize any global variables our application needs. |**| We have only one at this time -- the universal proc pointer for |**| our printing override. |**| --------------------------------------------------------------------- \**/ void DoSetup (void) { // Initialize our printing event override UPP gOurPrintingOverrideUPP = NewGXPrintingEventProc(MyPrintingEventOverride); } /**\ |**| --------------------------------------------------------------------- |**| DoDraw() |**| Draw the contents of the window. The first parameter is the window |**| to draw, and the second parameter is true if we're updating an existing |**| image. If that's the case, we don't want to change anything, but |**| just draw what's already there. |**| --------------------------------------------------------------------- \**/ void DoDraw (WindowPtr wind, Boolean updating) { #pragma unused (updating) GXDrawShape (GetDocShape(wind)); } /**\ |**| --------------------------------------------------------------------- |**| DoCreateNew() |**| This routine is called when a window needs to be created. |**| --------------------------------------------------------------------- \**/ OSErr DoCreateNew (void) { OSErr err = noErr; WindowPtr wind; // Get and create our window from the resource fork wind = GetNewWindow(rWindResource, nil, (WindowPtr)-1L); // Attach a default gxViewPort to it, create and iInitialize our // private data for it, and add a sample image to its page shape. if ( wind == NULL ) return (MemError()); GXIgnoreGraphicsNotice(transform_already_set); SetDefaultViewPort(GXNewWindowViewPort(wind)); GXPopGraphicsNotice(); err = DoWindowInit(wind); if ( err != noErr ) return err; CreateSampleImage(wind); return err; } /**\ |**| --------------------------------------------------------------------- |**| DoDispose() |**| This routine is called when a window needs to be disposed of. |**| --------------------------------------------------------------------- \**/ void DoDispose (WindowPtr wind) { TH_Doc doc; // You should always dispose of your GX graphics objects before tossing your window. // Why? It's generally good form and this approach guarantees that everything is // disposed. If you had not disposed of everything, the call to DisposeWindow should // dispose of the objects. If you are running the debugging version of QuickDraw GX // with notices set, you will receive a notice that you had not disposed of everything. // You can turn notices on in this file by setting gDebugging = TRUE (above). if ( wind != NULL ) { doc = (TH_Doc)GetWRefCon(wind); // Remember, this is where we stored our private data. GXDisposeShape(GetDocShape(wind)); // Dispose of this doc's shape. GXDisposeJob(GetDocJob(wind)); // Dispose of this doc's print job. DisposHandle((Handle) doc); // Dispose of our private data. DisposeWindow(wind); // Dispose of the window. } } /**\ |**| --------------------------------------------------------------------- |**| DoIdle() |**| This routine is called to do things while idling through the event loop. |**| --------------------------------------------------------------------- \**/ void DoIdle (WindowPtr wind) { } /**\ |**| --------------------------------------------------------------------- |**| DoTeardown() |**| This routine is called just before we quit to remove anything |**| persistent that might have been setup by DoSetup(). |**| --------------------------------------------------------------------- \**/ void DoTeardown (void) { DisposeRoutineDescriptor(gOurPrintingOverrideUPP); } /**\ |**| --------------------------------------------------------------------- |**| DoClick() |**| --------------------------------------------------------------------- \**/ void DoClick(WindowPtr window, Point p) { } /**\ |**| --------------------------------------------------------------------- |**| DoWindowInit() |**| In this function we create and initialize the the private document |**| structure for a new window. This structure contains the print job and |**| the shape which is drawn in the window. We store this data in a handle |**| and hang it off the window's refCon field for easy retrieval. By doing |**| this, rather than using globals, we can create many windows containing |**| unique print jobs and shapes. |**| --------------------------------------------------------------------- \**/ OSErr DoWindowInit (WindowPtr wind) { OSErr err = noErr; gxJob docJob; gxShape docPage; TH_Doc windDoc; // Create the page shape. We set the unique items attribute to make sure that each item // added to the picture has a unique reference. If this attribute was not set, we would // not see all copies of anything we add to the shape multiple times -- we'd just see // the last version added. docPage = GXNewShape(gxPictureType); GXSetShapeAttributes(docPage, (GXGetShapeAttributes(docPage) | gxUniqueItemsShape)); // Create a print job for this document. This will be the same as the system default until // the user goes through the dialogs for Page Setup or Print… err = GXNewJob(&docJob); // If there are no errors, create a handle the size of our document structure and store // the print job and page shape in it. Store the handle in the window's refCon field so // that we can get at it. (Note that the utility routines "GetDocJob" and "GetDocShape" // can be used to do this easily. if ( err == noErr ) { windDoc = (TH_Doc) NewHandleClear(sizeof(T_Doc)); if ( windDoc == NULL ) err = MemError(); else { (*windDoc)->docJob = docJob; (*windDoc)->docPage = docPage; SetWRefCon(wind, (long) windDoc); } // Now install our application override for PrintingEvent so that we can // support the new movable-modal printing dialog boxes. GXInstallApplicationOverride(docJob, gxPrintingEventMsg, gOurPrintingOverrideUPP); } return err; } /**\ |**| --------------------------------------------------------------------- |**| CreateSampleImage() |**| This function creates primitive shapes and adds them to the window's page shape. |**| --------------------------------------------------------------------- \**/ void CreateSampleImage (WindowPtr wind) { Rect ourWindowRect = wind->portRect; // the rectangle for this window // in QuickDraw coordinates gxShape layout; // the layout shape we build gxShape thePage; // this window's document shape gxRunControls runControls; // run controls for the layout shape gxLayoutOptions layoutOptions; // options for the layout shape gxStyle timesStyle; // a style record for a Times-based style gxStyle helveticaStyle; // ditto for Helvetica gxStyle baghdadStyle; // ditto for Baghdad gxStyle textStyles[5]; // an array of text style for our text runs // These are the five text runs for this layout shape, in pieces because they're // in different languages char *text1 = "Aetna "; // The following is "Macintosh" in Arabic: // meem, alif, kaf, noon, tah, wau, shin // (This assumes the standard Arabic character set for Macintosh, by the way) static char text2[] = {0xE5, 0xC7, 0xE3, 0xE6, 0xCA, 0xE8, 0xD4, 0}; char *text3 = " Office AWAY."; char *textRuns[3]; // an array of pointers to text runs short textLengths[3]; // an array of the lengths of each run short totalLength; // the total length of the layout's text short level0 = 0; // a variable to take the address of later gxPoint posn; // the position of the layout shape // First, initialize the textRuns array to point to the five text runs textRuns[0] = text1; textRuns[1] = text2; textRuns[2] = text3; // Next, initialize the textLengths and levelRunLengths arrays. MyStrLength() is // in this file. textLengths[0] = MyStrLength (text1); textLengths[1] = MyStrLength (text2); textLengths[2] = MyStrLength (text3); // totalLength is the length of all the text. totalLength = textLengths[0] + textLengths[1] + textLengths[2]; // make default gxLayoutOptions and gxRunControls structures InitializeLayoutOptions (&layoutOptions); InitializeRunControls (&runControls); // Position the layout half way down the left edge of the window. Set // the layout's width to the window's width and set the flushness to 1/2, this // will cause the layout to center in the window. Note that ourWindowRect is // not in fixed coordinates, so we have to make it fixed to use it. layoutOptions.width = ff(ourWindowRect.right - ourWindowRect.left); layoutOptions.flush = fract1/2; posn.x = 0; posn.y = ff((ourWindowRect.bottom - ourWindowRect.top) / 2); // Create the styles we'll use. The helveticaStyle is 38-point Helvetica Italics. // NewLayoutStyle is a library routine found in layout library.c, and // SetStyleCommonFace found in text library.c. helveticaStyle = NewLayoutStyle( (char *) "\pHelvetica", // the gxFontName for the style ff(38), // the text size in fixed point 0, // gxTextAttributes &runControls, // run controls (our default ones) nil, // run features (none for this style) 0, // count of run features nil); // style run overrides (none right now) SetStyleCommonFace(helveticaStyle, italic); // The second style is baghdadStyle -- Baghdad Plain (Arabic), 38 points. baghdadStyle = NewLayoutStyle( (char *) "\pBaghdad Plain", // gxFontName ff(38), // text size (fixed point) 0, // gxTextAttributes &runControls, // run controls (our default ones) nil, // run features (none) 0, // count of run features (none) nil); // style run overrides (none) // The final style is 38-point Times Roman with imposed right-to-left direction. runControls.flags |= gxImposeRightToLeft; timesStyle = NewLayoutStyle( (char *) "\pTimes Roman", // gxFontName ff(38), // text size (fixed point) 0, // gxTextAttributes &runControls, // run controls (our altered ones) nil, // run features (none) 0, // count of run features (none) nil); // style run overrides (none) // Initialize the textStyles array so that each of the 3 runs has the right style textStyles[0] = helveticaStyle; textStyles[1] = baghdadStyle; textStyles[2] = timesStyle; // Setup complete! Build the layout. layout = GXNewLayout( 3, // count of text runs textLengths, // array of lengths of each run (void *) textRuns, // array of pointers to the text 3, // count of style runs textLengths, // array of the byte lengths of each run textStyles, // array of the styles 1, // number of levels in the layout &totalLength, // array of the lengths of each level &level0, // array of the levels &layoutOptions, // options (default) &posn); // position of the layout shape // Retrieve the page shape so we can add to it. thePage = GetDocShape(wind); // Add the layout to the window's picture shape. AddToShape is in shape library.c. AddToShape(thePage, layout); // Now that the shape is added to the picture, dispose of it and our styles GXDisposeShape(layout); GXDisposeStyle(helveticaStyle); GXDisposeStyle(baghdadStyle); GXDisposeStyle(timesStyle); // Invalidate the window's portRect so that everything gets updated. SetPort(wind); InvalRect(&ourWindowRect); }